A Typed Calculus Supporting Shallow Embeddings of Abstract Machines

machines and reductions in a system of proof terms for a version the sequent calculus. We believe that by doing so we shed light on some essential characteristics of abstract machines, proofs in sequent calculus systems, and weak normalization of λ-terms. The machines that we consider are the (callby-name) Krivine machine and a call-by-value machine that may be called a “right-to-left CEK machine” but with some modifications can be seen as a proto-ZINC machine. The formal connection we exhibit is, in fact, an embedding of the machines into the term calculus. We embed run-time data structures, such as the control stack and environment, in such a way that the operational semantics of the machine corresponds to reduction steps in the calculus. The abstract machine state, including the code that it executes, is captured as a term; the abstract machine transitions are captured as term reductions. This is in contrast to specifying the operational semantics on top of the calculus. In other words, our goal is to provide a shallow embedding of an abstract machine in a calculus/logic, as opposed to a deep embedding. This allows reasoning about the machine inside the logic itself instead of on top of it. The logical formulae that are assigned to proof terms provide a type system for the term language via the Curry-Howard isomorphism, and because of the method of embedding the machines into the terms, this type system can be directly lifted to the machine code and machine states, thereby allowing an elegant and simple formulation of safety, based on the subject reduction theorem of the calculus.